package com.zw.utils;

import java.util.HashMap;
import java.util.Map;

/**
 * 类型转换工具类
 * 根据类型字符串将内容转换为对应的Java类型
 * 支持null或空字符串转换为类型默认值
 */
public class TypeConversionUtil {

    // 类型映射关系
    private static final Map<String, Class<?>> TYPE_MAPPING = new HashMap<>();

    // 类型默认值映射
    private static final Map<String, Object> TYPE_DEFAULTS = new HashMap<>();

    static {
        // 类型映射
        TYPE_MAPPING.put("bigint", Long.class);
        TYPE_MAPPING.put("int", Integer.class);
        TYPE_MAPPING.put("float", Float.class);
        TYPE_MAPPING.put("double", Double.class);

        // 默认值映射
        TYPE_DEFAULTS.put("bigint", 0L);
        TYPE_DEFAULTS.put("int", 0);
        TYPE_DEFAULTS.put("float", 0.0f);
        TYPE_DEFAULTS.put("double", 0.0);
    }

    /**
     * 私有构造函数，防止实例化
     */
    private TypeConversionUtil() {
        throw new UnsupportedOperationException("工具类不允许实例化");
    }

    /**
     * 将字符串内容转换为指定类型的对象
     * 如果content为null或空字符串，返回对应类型的默认值
     * @param content 要转换的字符串内容
     * @param type 目标类型字符串 (bigint, int, float, double)
     * @return 转换后的对象
     * @throws IllegalArgumentException 如果类型不支持或内容无法转换
     */
    public static Object convert(String content, String type) {
        // 处理null或空字符串
        if (content == null || content.trim().isEmpty()) {
            return getDefaultValue(type);
        }

        if (!TYPE_MAPPING.containsKey(type)) {
            throw new IllegalArgumentException("不支持的转换类型: " + type +
                    ", 支持的类型有: " + TYPE_MAPPING.keySet());
        }

        try {
            // 理论上不会执行到这里
            return switch (type) {
                case "bigint" -> Long.parseLong(content.trim());
                case "int" -> Integer.parseInt(content.trim());
                case "float" -> Float.parseFloat(content.trim());
                case "double" -> Double.parseDouble(content.trim());
                default -> throw new IllegalArgumentException("不支持的转换类型: " + type);
            };
        } catch (NumberFormatException e) {
            throw new IllegalArgumentException("无法将内容 '" + content +
                    "' 转换为类型: " + type, e);
        }
    }

    /**
     * 获取指定类型的默认值
     * @param type 类型字符串
     * @return 对应类型的默认值
     * @throws IllegalArgumentException 如果类型不支持
     */
    public static Object getDefaultValue(String type) {
        if (!TYPE_DEFAULTS.containsKey(type)) {
            throw new IllegalArgumentException("不支持的转换类型: " + type +
                    ", 支持的类型有: " + TYPE_DEFAULTS.keySet());
        }
        return TYPE_DEFAULTS.get(type);
    }

    /**
     * 将字符串内容转换为指定类型的对象，并指定自定义默认值
     * @param content 要转换的字符串内容
     * @param type 目标类型字符串 (bigint, int, float, double)
     * @param defaultValue 转换失败时返回的默认值
     * @return 转换后的对象或默认值
     */
    public static Object convertWithDefault(String content, String type, Object defaultValue) {
        try {
            return convert(content, type);
        } catch (Exception e) {
            return defaultValue;
        }
    }

    /**
     * 检查是否支持指定的类型转换
     * @param type 要检查的类型字符串
     * @return 如果支持返回true，否则返回false
     */
    public static boolean isTypeSupported(String type) {
        return TYPE_MAPPING.containsKey(type);
    }

    /**
     * 获取所有支持的类型
     * @return 支持的类型集合
     */
    public static java.util.Set<String> getSupportedTypes() {
        return TYPE_MAPPING.keySet();
    }

    /**
     * 获取类型对应的Java类
     * @param type 类型字符串
     * @return 对应的Java类
     * @throws IllegalArgumentException 如果类型不支持
     */
    public static Class<?> getTypeClass(String type) {
        if (!TYPE_MAPPING.containsKey(type)) {
            throw new IllegalArgumentException("不支持的转换类型: " + type +
                    ", 支持的类型有: " + TYPE_MAPPING.keySet());
        }
        return TYPE_MAPPING.get(type);
    }
}